home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / macgambit-20-compiler-src-p2 / Interp⁄Comp (.scm) / target-m68000-3.scm < prev    next >
Encoding:
Text File  |  1994-07-26  |  27.2 KB  |  413 lines  |  [TEXT/gamI]
  1. ;==============================================================================
  2.  
  3. ; file: "target-m68000-3.scm"
  4.  
  5. ;------------------------------------------------------------------------------
  6. ;
  7. ; Primitive procedure database (for M68000):
  8.  
  9. ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  10.  
  11. (define prim-procs '
  12. (
  13. ;                                    side-effects?  strictness  result
  14. ;                                                \  pattern     type
  15. ; name                            call pattern     \   \          |
  16. ;  /                                    \            \   \        |
  17. ("not"                                   (1)          #f 0        BOOLEAN)
  18. ("boolean?"                              (1)          #f 0        BOOLEAN)
  19. ("eqv?"                                  (2)          #f 0        BOOLEAN)
  20. ("eq?"                                   (2)          #f 0        BOOLEAN)
  21. ("equal?"                                (2)          #f 0        BOOLEAN)
  22. ("pair?"                                 (1)          #f 0        BOOLEAN)
  23. ("cons"                                  (2)          #f ()       PAIR   )
  24. ("car"                                   (1)          #f 0        (#f)   )
  25. ("cdr"                                   (1)          #f 0        (#f)   )
  26. ("set-car!"                              (2)          #t (1)      PAIR   )
  27. ("set-cdr!"                              (2)          #t (1)      PAIR   )
  28. ("caar"                                  (1)          #f 0        (#f)   )
  29. ("cadr"                                  (1)          #f 0        (#f)   )
  30. ("cdar"                                  (1)          #f 0        (#f)   )
  31. ("cddr"                                  (1)          #f 0        (#f)   )
  32. ("caaar"                                 (1)          #f 0        (#f)   )
  33. ("caadr"                                 (1)          #f 0        (#f)   )
  34. ("cadar"                                 (1)          #f 0        (#f)   )
  35. ("caddr"                                 (1)          #f 0        (#f)   )
  36. ("cdaar"                                 (1)          #f 0        (#f)   )
  37. ("cdadr"                                 (1)          #f 0        (#f)   )
  38. ("cddar"                                 (1)          #f 0        (#f)   )
  39. ("cdddr"                                 (1)          #f 0        (#f)   )
  40. ("caaaar"                                (1)          #f 0        (#f)   )
  41. ("caaadr"                                (1)          #f 0        (#f)   )
  42. ("caadar"                                (1)          #f 0        (#f)   )
  43. ("caaddr"                                (1)          #f 0        (#f)   )
  44. ("cadaar"                                (1)          #f 0        (#f)   )
  45. ("cadadr"                                (1)          #f 0        (#f)   )
  46. ("caddar"                                (1)          #f 0        (#f)   )
  47. ("cadddr"                                (1)          #f 0        (#f)   )
  48. ("cdaaar"                                (1)          #f 0        (#f)   )
  49. ("cdaadr"                                (1)          #f 0        (#f)   )
  50. ("cdadar"                                (1)          #f 0        (#f)   )
  51. ("cdaddr"                                (1)          #f 0        (#f)   )
  52. ("cddaar"                                (1)          #f 0        (#f)   )
  53. ("cddadr"                                (1)          #f 0        (#f)   )
  54. ("cdddar"                                (1)          #f 0        (#f)   )
  55. ("cddddr"                                (1)          #f 0        (#f)   )
  56. ("null?"                                 (1)          #f 0        BOOLEAN)
  57. ("list?"                                 (1)          #f 0        BOOLEAN)
  58. ("list"                                  0            #f ()       LIST   )
  59. ("length"                                (1)          #f 0        INTEGER)
  60. ("append"                                0            #f 0        LIST   )
  61. ("reverse"                               (1)          #f 0        LIST   )
  62. ("list-ref"                              (2)          #f 0        (#f)   )
  63. ("memq"                                  (2)          #f 0        LIST   )
  64. ("memv"                                  (2)          #f 0        LIST   )
  65. ("member"                                (2)          #f 0        LIST   )
  66. ("assq"                                  (2)          #f 0        #f     )
  67. ("assv"                                  (2)          #f 0        #f     )
  68. ("assoc"                                 (2)          #f 0        #f     )
  69. ("symbol?"                               (1)          #f 0        BOOLEAN)
  70. ("symbol->string"                        (1)          #f 0        STRING )
  71. ("string->symbol"                        (1)          #f 0        SYMBOL )
  72. ("number?"                               (1)          #f 0        BOOLEAN)
  73. ("complex?"                              (1)          #f 0        BOOLEAN)
  74. ("real?"                                 (1)          #f 0        BOOLEAN)
  75. ("rational?"                             (1)          #f 0        BOOLEAN)
  76. ("integer?"                              (1)          #f 0        BOOLEAN)
  77. ("exact?"                                (1)          #f 0        BOOLEAN)
  78. ("inexact?"                              (1)          #f 0        BOOLEAN)
  79. ("="                                     0            #f 0        BOOLEAN)
  80. ("<"                                     0            #f 0        BOOLEAN)
  81. (">"                                     0            #f 0        BOOLEAN)
  82. ("<="                                    0            #f 0        BOOLEAN)
  83. (">="                                    0            #f 0        BOOLEAN)
  84. ("zero?"                                 (1)          #f 0        BOOLEAN)
  85. ("positive?"                             (1)          #f 0        BOOLEAN)
  86. ("negative?"                             (1)          #f 0        BOOLEAN)
  87. ("odd?"                                  (1)          #f 0        BOOLEAN)
  88. ("even?"                                 (1)          #f 0        BOOLEAN)
  89. ("max"                                   1            #f 0        NUMBER )
  90. ("min"                                   1            #f 0        NUMBER )
  91. ("+"                                     0            #f 0        NUMBER )
  92. ("*"                                     0            #f 0        NUMBER )
  93. ("-"                                     1            #f 0        NUMBER )
  94. ("/"                                     1            #f 0        NUMBER )
  95. ("abs"                                   (1)          #f 0        NUMBER )
  96. ("quotient"                              1            #f 0        INTEGER)
  97. ("remainder"                             (2)          #f 0        INTEGER)
  98. ("modulo"                                (2)          #f 0        INTEGER)
  99. ("gcd"                                   1            #f 0        INTEGER)
  100. ("lcm"                                   1            #f 0        INTEGER)
  101. ("numerator"                             (1)          #f 0        INTEGER)
  102. ("denominator"                           (1)          #f 0        INTEGER)
  103. ("floor"                                 (1)          #f 0        INTEGER)
  104. ("ceiling"                               (1)          #f 0        INTEGER)
  105. ("truncate"                              (1)          #f 0        INTEGER)
  106. ("round"                                 (1)          #f 0        INTEGER)
  107. ("rationalize"                           (2)          #f 0        NUMBER )
  108. ("exp"                                   (1)          #f 0        NUMBER )
  109. ("log"                                   (1)          #f 0        NUMBER )
  110. ("sin"                                   (1)          #f 0        NUMBER )
  111. ("cos"                                   (1)          #f 0        NUMBER )
  112. ("tan"                                   (1)          #f 0        NUMBER )
  113. ("asin"                                  (1)          #f 0        NUMBER )
  114. ("acos"                                  (1)          #f 0        NUMBER )
  115. ("atan"                                  (1 2)        #f 0        NUMBER )
  116. ("sqrt"                                  (1)          #f 0        NUMBER )
  117. ("expt"                                  (2)          #f 0        NUMBER )
  118. ("make-rectangular"                      (2)          #f 0        NUMBER )
  119. ("make-polar"                            (2)          #f 0        NUMBER )
  120. ("real-part"                             (1)          #f 0        REAL   )
  121. ("imag-part"                             (1)          #f 0        REAL   )
  122. ("magnitude"                             (1)          #f 0        REAL   )
  123. ("angle"                                 (1)          #f 0        REAL   )
  124. ("exact->inexact"                        (1)          #f 0        NUMBER )
  125. ("inexact->exact"                        (1)          #f 0        NUMBER )
  126. ("number->string"                        (1 2)        #f 0        STRING )
  127. ("string->number"                        (1 2)        #f 0        NUMBER )
  128. ("char?"                                 (1)          #f 0        BOOLEAN)
  129. ("char=?"                                0            #f 0        BOOLEAN)
  130. ("char<?"                                0            #f 0        BOOLEAN)
  131. ("char>?"                                0            #f 0        BOOLEAN)
  132. ("char<=?"                               0            #f 0        BOOLEAN)
  133. ("char>=?"                               0            #f 0        BOOLEAN)
  134. ("char-ci=?"                             0            #f 0        BOOLEAN)
  135. ("char-ci<?"                             0            #f 0        BOOLEAN)
  136. ("char-ci>?"                             0            #f 0        BOOLEAN)
  137. ("char-ci<=?"                            0            #f 0        BOOLEAN)
  138. ("char-ci>=?"                            0            #f 0        BOOLEAN)
  139. ("char-alphabetic?"                      (1)          #f 0        BOOLEAN)
  140. ("char-numeric?"                         (1)          #f 0        BOOLEAN)
  141. ("char-whitespace?"                      (1)          #f 0        BOOLEAN)
  142. ("char-upper-case?"                      (1)          #f 0        BOOLEAN)
  143. ("char-lower-case?"                      (1)          #f 0        BOOLEAN)
  144. ("char->integer"                         (1)          #f 0        INTEGER)
  145. ("integer->char"                         (1)          #f 0        CHAR   )
  146. ("char-upcase"                           (1)          #f 0        CHAR   )
  147. ("char-downcase"                         (1)          #f 0        CHAR   )
  148. ("string?"                               (1)          #f 0        BOOLEAN)
  149. ("make-string"                           (1 2)        #f 0        STRING )
  150. ("string"                                0            #f 0        STRING )
  151. ("string-length"                         (1)          #f 0        INTEGER)
  152. ("string-ref"                            (2)          #f 0        CHAR   )
  153. ("string-set!"                           (3)          #t 0        STRING )
  154. ("string=?"                              0            #f 0        BOOLEAN)
  155. ("string<?"                              0            #f 0        BOOLEAN)
  156. ("string>?"                              0            #f 0        BOOLEAN)
  157. ("string<=?"                             0            #f 0        BOOLEAN)
  158. ("string>=?"                             0            #f 0        BOOLEAN)
  159. ("string-ci=?"                           0            #f 0        BOOLEAN)
  160. ("string-ci<?"                           0            #f 0        BOOLEAN)
  161. ("string-ci>?"                           0            #f 0        BOOLEAN)
  162. ("string-ci<=?"                          0            #f 0        BOOLEAN)
  163. ("string-ci>=?"                          0            #f 0        BOOLEAN)
  164. ("substring"                             (3)          #f 0        STRING )
  165. ("string-append"                         0            #f 0        STRING )
  166. ("vector?"                               (1)          #f 0        BOOLEAN)
  167. ("make-vector"                           (1 2)        #f (1)      VECTOR )
  168. ("vector"                                0            #f ()       VECTOR )
  169. ("vector-length"                         (1)          #f 0        INTEGER)
  170. ("vector-ref"                            (2)          #f 0        (#f)   )
  171. ("vector-set!"                           (3)          #t (1 2)    VECTOR )
  172. ("procedure?"                            (1)          #f 0        BOOLEAN)
  173. ("apply"                                 2            #t 0        (#f)   )
  174. ("map"                                   2            #t 0        LIST   )
  175. ("for-each"                              2            #t 0        #f     )
  176. ("call-with-current-continuation"        (1)          #t 0        (#f)   )
  177. ("call-with-input-file"                  (2)          #t 0        (#f)   )
  178. ("call-with-output-file"                 (2)          #t 0        (#f)   )
  179. ("input-port?"                           (1)          #f 0        BOOLEAN)
  180. ("output-port?"                          (1)          #f 0        BOOLEAN)
  181. ("current-input-port"                    (0)          #f 0        PORT   )
  182. ("current-output-port"                   (0)          #f 0        PORT   )
  183. ("open-input-file"                       (1)          #t 0        PORT   )
  184. ("open-output-file"                      (1)          #t 0        PORT   )
  185. ("close-input-port"                      (1)          #t 0        #f     )
  186. ("close-output-port"                     (1)          #t 0        #f     )
  187. ("eof-object?"                           (1)          #f 0        BOOLEAN)
  188. ("read"                                  (0 1)        #t 0        #f     )
  189. ("read-char"                             (0 1)        #t 0        #f     )
  190. ("peek-char"                             (0 1)        #t 0        #f     )
  191. ("write"                                 (0 1)        #t 0        #f     )
  192. ("display"                               (0 1)        #t 0        #f     )
  193. ("newline"                               (0 1)        #t 0        #f     )
  194. ("write-char"                            (1 2)        #t 0        #f     )
  195.  
  196. ; for R4RS Scheme
  197.  
  198. ("list-tail"                             (2)          #f 0        (#f)   )
  199. ("string->list"                          (1)          #f 0        LIST   )
  200. ("list->string"                          (1)          #f 0        STRING )
  201. ("string-copy"                           (1)          #f 0        STRING )
  202. ("string-fill!"                          (2)          #t 0        STRING )
  203. ("vector->list"                          (1)          #f 0        LIST   )
  204. ("list->vector"                          (1)          #f 0        VECTOR )
  205. ("vector-fill!"                          (2)          #t 0        VECTOR )
  206. ("force"                                 (1)          #t 0        #f     )
  207. ("with-input-from-file"                  (2)          #t 0        (#f)   )
  208. ("with-output-to-file"                   (2)          #t 0        (#f)   )
  209. ("char-ready?"                           (0 1)        #f 0        BOOLEAN)
  210. ("load"                                  (1)          #t 0        (#f)   )
  211. ("transcript-on"                         (1)          #t 0        #f     )
  212. ("transcript-off"                        (0)          #t 0        #f     )
  213.  
  214. ; for Multilisp
  215.  
  216. ("touch"                                 (1)          #t 0        #f     )
  217.  
  218. ; for system interface
  219.  
  220. ("##type"                                (1)          #f ()       INTEGER)
  221. ("##type-cast"                           (2)          #f ()       (#f)   )
  222. ("##subtype"                             (1)          #f ()       INTEGER)
  223. ("##subtype-set!"                        (2)          #t ()       #f     )
  224.  
  225. ("##not"                                 (1)          #f ()       BOOLEAN)
  226. ("##null?"                               (1)          #f ()       BOOLEAN)
  227. ("##unassigned?"                         (1)          #f ()       BOOLEAN)
  228. ("##unbound?"                            (1)          #f ()       BOOLEAN)
  229. ("##eq?"                                 (2)          #f ()       BOOLEAN)
  230.  
  231. ("##fixnum?"                             (1)          #f ()       BOOLEAN)
  232. ("##special?"                            (1)          #f ()       BOOLEAN)
  233. ("##pair?"                               (1)          #f ()       BOOLEAN)
  234. ("##weak-pair?"                          (1)          #f ()       BOOLEAN)
  235. ("##subtyped?"                           (1)          #f ()       BOOLEAN)
  236. ("##procedure?"                          (1)          #f ()       BOOLEAN)
  237. ("##placeholder?"                        (1)          #f ()       BOOLEAN)
  238. ("##vector?"                             (1)          #f ()       BOOLEAN)
  239. ("##symbol?"                             (1)          #f ()       BOOLEAN)
  240. ("##ratnum?"                             (1)          #f ()       BOOLEAN)
  241. ("##cpxnum?"                             (1)          #f ()       BOOLEAN)
  242. ("##string?"                             (1)          #f ()       BOOLEAN)
  243. ("##bignum?"                             (1)          #f ()       BOOLEAN)
  244. ("##flonum?"                             (1)          #f ()       BOOLEAN)
  245. ("##char?"                               (1)          #f ()       BOOLEAN)
  246.  
  247. ("##fixnum.+"                            0            #f ()       INTEGER)
  248. ("##fixnum.*"                            0            #f ()       INTEGER)
  249. ("##fixnum.-"                            1            #f ()       INTEGER)
  250. ("##fixnum.quotient"                     (2)          #f ()       INTEGER)
  251. ("##fixnum.remainder"                    (2)          #f ()       INTEGER)
  252. ("##fixnum.modulo"                       (2)          #f ()       INTEGER)
  253. ("##fixnum.logior"                       0            #f ()       INTEGER)
  254. ("##fixnum.logxor"                       0            #f ()       INTEGER)
  255. ("##fixnum.logand"                       0            #f ()       INTEGER)
  256. ("##fixnum.lognot"                       (1)          #f ()       INTEGER)
  257. ("##fixnum.ash"                          (2)          #f ()       INTEGER)
  258. ("##fixnum.lsh"                          (2)          #f ()       INTEGER)
  259. ("##fixnum.zero?"                        (1)          #f ()       BOOLEAN)
  260. ("##fixnum.positive?"                    (1)          #f ()       BOOLEAN)
  261. ("##fixnum.negative?"                    (1)          #f ()       BOOLEAN)
  262. ("##fixnum.odd?"                         (1)          #f ()       BOOLEAN)
  263. ("##fixnum.even?"                        (1)          #f ()       BOOLEAN)
  264. ("##fixnum.="                            0            #f ()       BOOLEAN)
  265. ("##fixnum.<"                            0            #f ()       BOOLEAN)
  266. ("##fixnum.>"                            0            #f ()       BOOLEAN)
  267. ("##fixnum.<="                           0            #f ()       BOOLEAN)
  268. ("##fixnum.>="                           0            #f ()       BOOLEAN)
  269.  
  270. ("##logior"                              0            #f ()       INTEGER)
  271. ("##logxor"                              0            #f ()       INTEGER)
  272. ("##logand"                              0            #f ()       INTEGER)
  273. ("##lognot"                              (1)          #f ()       INTEGER)
  274. ("##ash"                                 (2)          #f ()       INTEGER)
  275.  
  276. ("##flonum.->fixnum"                     (1)          #f ()       INTEGER)
  277. ("##flonum.<-fixnum"                     (1)          #f ()       REAL   )
  278. ("##flonum.+"                            0            #f ()       REAL   )
  279. ("##flonum.*"                            0            #f ()       REAL   )
  280. ("##flonum.-"                            1            #f ()       REAL   )
  281. ("##flonum./"                            1            #f ()       REAL   )
  282. ("##flonum.abs"                          (1)          #f ()       REAL   )
  283. ("##flonum.truncate"                     (1)          #f ()       REAL   )
  284. ("##flonum.round"                        (1)          #f ()       REAL   )
  285. ("##flonum.exp"                          (1)          #f ()       REAL   )
  286. ("##flonum.log"                          (1)          #f ()       REAL   )
  287. ("##flonum.sin"                          (1)          #f ()       REAL   )
  288. ("##flonum.cos"                          (1)          #f ()       REAL   )
  289. ("##flonum.tan"                          (1)          #f ()       REAL   )
  290. ("##flonum.asin"                         (1)          #f ()       REAL   )
  291. ("##flonum.acos"                         (1)          #f ()       REAL   )
  292. ("##flonum.atan"                         (1)          #f ()       REAL   )
  293. ("##flonum.sqrt"                         (1)          #f ()       REAL   )
  294. ("##flonum.zero?"                        (1)          #f ()       BOOLEAN)
  295. ("##flonum.positive?"                    (1)          #f ()       BOOLEAN)
  296. ("##flonum.negative?"                    (1)          #f ()       BOOLEAN)
  297. ("##flonum.="                            0            #f ()       BOOLEAN)
  298. ("##flonum.<"                            0            #f ()       BOOLEAN)
  299. ("##flonum.>"                            0            #f ()       BOOLEAN)
  300. ("##flonum.<="                           0            #f ()       BOOLEAN)
  301. ("##flonum.>="                           0            #f ()       BOOLEAN)
  302.  
  303. ("##char=?"                              0            #f ()       BOOLEAN)
  304. ("##char<?"                              0            #f ()       BOOLEAN)
  305. ("##char>?"                              0            #f ()       BOOLEAN)
  306. ("##char<=?"                             0            #f ()       BOOLEAN)
  307. ("##char>=?"                             0            #f ()       BOOLEAN)
  308.  
  309. ("##cons"                                (2)          #f ()       PAIR   )
  310. ("##set-car!"                            (2)          #t ()       PAIR   )
  311. ("##set-cdr!"                            (2)          #t ()       PAIR   )
  312. ("##car"                                 (1)          #f ()       (#f)   )
  313. ("##cdr"                                 (1)          #f ()       (#f)   )
  314. ("##caar"                                (1)          #f ()       (#f)   )
  315. ("##cadr"                                (1)          #f ()       (#f)   )
  316. ("##cdar"                                (1)          #f ()       (#f)   )
  317. ("##cddr"                                (1)          #f ()       (#f)   )
  318. ("##caaar"                               (1)          #f ()       (#f)   )
  319. ("##caadr"                               (1)          #f ()       (#f)   )
  320. ("##cadar"                               (1)          #f ()       (#f)   )
  321. ("##caddr"                               (1)          #f ()       (#f)   )
  322. ("##cdaar"                               (1)          #f ()       (#f)   )
  323. ("##cdadr"                               (1)          #f ()       (#f)   )
  324. ("##cddar"                               (1)          #f ()       (#f)   )
  325. ("##cdddr"                               (1)          #f ()       (#f)   )
  326. ("##caaaar"                              (1)          #f ()       (#f)   )
  327. ("##caaadr"                              (1)          #f ()       (#f)   )
  328. ("##caadar"                              (1)          #f ()       (#f)   )
  329. ("##caaddr"                              (1)          #f ()       (#f)   )
  330. ("##cadaar"                              (1)          #f ()       (#f)   )
  331. ("##cadadr"                              (1)          #f ()       (#f)   )
  332. ("##caddar"                              (1)          #f ()       (#f)   )
  333. ("##cadddr"                              (1)          #f ()       (#f)   )
  334. ("##cdaaar"                              (1)          #f ()       (#f)   )
  335. ("##cdaadr"                              (1)          #f ()       (#f)   )
  336. ("##cdadar"                              (1)          #f ()       (#f)   )
  337. ("##cdaddr"                              (1)          #f ()       (#f)   )
  338. ("##cddaar"                              (1)          #f ()       (#f)   )
  339. ("##cddadr"                              (1)          #f ()       (#f)   )
  340. ("##cdddar"                              (1)          #f ()       (#f)   )
  341. ("##cddddr"                              (1)          #f ()       (#f)   )
  342.  
  343. ("##weak-cons"                           (2)          #f ()       PAIR   )
  344. ("##weak-set-car!"                       (2)          #t ()       PAIR   )
  345. ("##weak-set-cdr!"                       (2)          #t ()       PAIR   )
  346. ("##weak-car"                            (1)          #f ()       (#f)   )
  347. ("##weak-cdr"                            (1)          #f ()       (#f)   )
  348.  
  349. ("##vector"                              0            #f ()       VECTOR )
  350. ("##make-vector"                         (2)          #f ()       VECTOR )
  351. ("##vector-length"                       (1)          #f ()       INTEGER)
  352. ("##vector-ref"                          (2)          #f ()       (#f)   )
  353. ("##vector-set!"                         (3)          #t ()       VECTOR )
  354. ("##vector-shrink!"                      (2)          #t ()       VECTOR )
  355.  
  356. ("##string"                              0            #f ()       STRING )
  357. ("##make-string"                         (2)          #f ()       STRING )
  358. ("##string-length"                       (1)          #f ()       INTEGER)
  359. ("##string-ref"                          (2)          #f ()       CHAR   )
  360. ("##string-set!"                         (3)          #t ()       STRING )
  361. ("##string-shrink!"                      (2)          #t ()       STRING )
  362.  
  363. ("##vector8"                             0            #f ()       STRING )
  364. ("##make-vector8"                        (2)          #f ()       STRING )
  365. ("##vector8-length"                      (1)          #f ()       INTEGER)
  366. ("##vector8-ref"                         (2)          #f ()       INTEGER)
  367. ("##vector8-set!"                        (3)          #t ()       STRING )
  368. ("##vector8-shrink!"                     (2)          #t ()       STRING )
  369.  
  370. ("##vector16"                            0            #f ()       STRING )
  371. ("##make-vector16"                       (2)          #f ()       STRING )
  372. ("##vector16-length"                     (1)          #f ()       INTEGER)
  373. ("##vector16-ref"                        (2)          #f ()       INTEGER)
  374. ("##vector16-set!"                       (3)          #t ()       STRING )
  375. ("##vector16-shrink!"                    (2)          #t ()       STRING )
  376.  
  377. ("##slot-ref"                            (2)          #f ()       (#f)   )
  378. ("##slot-set!"                           (3)          #t ()       #f     )
  379.  
  380. ("##make-cell"                           (1)          #f ()       PAIR   )
  381. ("##cell-ref"                            (1)          #f ()       (#f)   )
  382. ("##cell-set!"                           (2)          #t ()       PAIR   )
  383.  
  384. ("##pstate"                              (0)          #f ()       #f     )
  385.  
  386. ("##touch"                               (1)          #t 0        #f     )
  387.  
  388. ("##apply"                               (2)          #t ()       (#f)   )
  389. ("##call-with-current-continuation"      (1)          #t ()       (#f)   )
  390. ("##global-var"                          (1)          #t ()       #f     )
  391. ("##global-var-ref"                      (1)          #f ()       (#f)   )
  392. ("##global-var-set!"                     (2)          #t ()       #f     )
  393.  
  394. ("##atomic-car"                          (1)          #f ()       (#f)   )
  395. ("##atomic-cdr"                          (1)          #f ()       (#f)   )
  396. ("##atomic-set-car!"                     (2)          #t ()       PAIR   )
  397. ("##atomic-set-cdr!"                     (2)          #t ()       PAIR   )
  398. ("##atomic-set-car-if-eq?!"              (3)          #t ()       BOOLEAN)
  399. ("##atomic-set-cdr-if-eq?!"              (3)          #t ()       BOOLEAN)
  400.  
  401. ; for front end
  402.  
  403. ("##quasi-append"                        0            #f 0        LIST   )
  404. ("##quasi-list"                          0            #f ()       LIST   )
  405. ("##quasi-cons"                          (2)          #f ()       PAIR   )
  406. ("##quasi-list->vector"                  (1)          #f 0        VECTOR )
  407. ("##case-memv"                           (2)          #f 0        LIST   )
  408.  
  409. )
  410. )
  411.  
  412. ;==============================================================================
  413.